package cn.nexd.map.rendering.core.componet;


import android.content.Context;
import android.content.res.AssetManager;
import android.content.res.Resources;
import android.graphics.Color;
import android.util.AttributeSet;
import android.widget.FrameLayout;
import android.widget.ImageView;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import cn.nexd.map.rendering.POIData;
import cn.nexd.map.rendering.SVGMapViewClickListener;
import cn.nexd.map.rendering.SVGMapViewListener;
import cn.nexd.map.rendering.SVGMapViewOtherClickListener;
import cn.nexd.map.rendering.core.SVGMapBaseOverlay;
import cn.nexd.map.rendering.core.componet.data.Feature;
import cn.nexd.map.rendering.core.componet.data.FloorsFeature;


public class SVGMapView extends FrameLayout {
    private MapMainView mapMainView;

    private SVGMapController mapController;

    private ImageView brandImageView;
    private Context context;
    private AttributeSet attrs;
    private int defStyle;

    public SVGMapView(Context context) {
        this(context, null);
    }

    public SVGMapView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public SVGMapView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        this.context = context;
        this.attrs = attrs;
        this.defStyle = defStyle;
        mapMainView = new MapMainView(context, attrs, defStyle);
        this.addView(mapMainView);


    }

    public void setMaxZoomValue(float maxZoomValue) {
        mapMainView.setMaxZoomValue(maxZoomValue);
    }

    public void setMinZoomValue(float minZoomValue) {
        mapMainView.setMinZoomValue(minZoomValue);
    }

    public long getCurrentRenderingFloorId() {
        return mapMainView.getCurrentRenderingFloorId();
    }

    /**
     * 获取 SVGMapController 对象
     *
     * @return SVGMapController mapController
     */
    public SVGMapController getController() {
        if (this.mapController == null) {
            this.mapController = new SVGMapController(this);
        }
        return this.mapController;
    }

    /**
     * 设置 SVGMapViewListener 监听对象。
     *
     * @param idrMapViewListener
     */
    public void registerMapViewListener(SVGMapViewListener idrMapViewListener) {
        this.mapMainView.registeMapViewListener(idrMapViewListener);
    }

    public void registerMapViewClickListener(SVGMapViewClickListener mapViewClickListener) {
        this.mapMainView.registerMapViewClickListener(mapViewClickListener);
    }

    public void registerMapViewOtherClickListener(SVGMapViewOtherClickListener mapViewOtherClickListener) {
        this.mapMainView.registerMapViewOtherClickListener(mapViewOtherClickListener);
    }

    /**
     * 加载地图。
     *
     * @param svgString
     */
    public void loadMap(String svgString) {
        this.mapMainView.loadMap(svgString);
    }

    public void loadMap(InputStream svgInputStream) {
        this.mapMainView.loadMap(svgInputStream);
    }

    public void loadMap(Resources resources, int resId) {
        this.mapMainView.loadMap(resources, resId);
    }

    public void loadMap(AssetManager assetMngr, String svgPath) {
        this.mapMainView.loadMap(assetMngr, svgPath);
    }


    //    public void setBrandBitmap(Bitmap bitmap) {
    //        this.brandImageView.setImageBitmap(bitmap);
    //    }

    /**
     * 刷新 Map，在修改地图数据之后调用。用于将地图渲染到屏幕。
     */
    public void refresh() {
        this.mapMainView.refresh();
    }

    /**
     * @return 返回地图是否加载完毕。
     */
    public boolean isMapLoadFinsh() {
        return this.mapMainView.isMapLoadFinsh();
    }

    /**
     * get the current map.
     * It will be callback in the map listener of 'onGetCurrentMap'
     */
    public void getCurrentMap() {
        this.mapMainView.getCurrentMap();
    }

    public float getCurrentRotateDegrees() {
        return this.mapMainView.getCurrentRotateDegrees();
    }

    public void setCurrentRotationDegrees(float degrees, float pivotX, float pivotY) {
        this.mapMainView.setCurrentRotationDegrees(degrees, pivotX, pivotY);
    }

    public float getCurrentZoomValue() {
        return this.mapMainView.getCurrentZoomValue();
    }


    public float getMaxZoomValue() {
        return this.mapMainView.getMaxZoomValue();
    }


    public float getMinZoomValue() {
        return this.mapMainView.getMinZoomValue();
    }


    // 坐标系转换（屏幕坐标到地图坐标）
    public float[] getMapCoordinateWithScreenCoordinate(float screenX, float screenY) {
        return this.mapMainView.getMapCoordinateWithScreenCoordinate(screenX, screenY);
    }

    //    public List<SVGMapBaseOverlay> getOverLays() {
    //        return this.mapMainView.getOverLays();
    //    }


    // 添加Overlay 到地图
    public void addOverlay(SVGMapBaseOverlay overlay, int tag) {
        this.mapMainView.addOverlay(overlay, tag);
    }

    // 根据 Overlay 移除闪烁点
    public void removeOverlay(SVGMapBaseOverlay overlay) {
        this.mapMainView.removeOverlay(overlay);
    }

    // 根据tag移除图层
    public void removeOverlay(int overlayTag) {
        this.mapMainView.removeOverlay(overlayTag);
    }

    // 一次性移除所有的图层（基本图层除外，干净彻底）
    public void removeAllOverlay() {
        this.mapMainView.removeAllOverlay();
    }

    public void onDestroy() {
        this.mapMainView.onDestroy();
    }

    public void onPause() {
        this.mapMainView.onPause();
    }

    public void onResume() {
        this.mapMainView.onResume();
    }

    public void setCurrentFloor(String floorId, final SVGMapViewListener svgMapViewListener) {
        this.setBackgroundColor(Color.WHITE);
        this.removeView(mapMainView);
        mapMainView = new MapMainView(context, attrs, defStyle);
        this.addView(mapMainView);
        this.mapMainView.registeMapViewListener(svgMapViewListener);
        this.loadMap(floorId + ".svg");
    }

    /**
     * @param floorId
     * @param svgMapViewListener
     * @param maxZoomValue       最大缩放级别
     */
    public void setCurrentFloor(String floorId, final SVGMapViewListener svgMapViewListener, float maxZoomValue) {
        this.setBackgroundColor(Color.WHITE);
        this.removeView(mapMainView);
        mapMainView = new MapMainView(context, attrs, defStyle);
        this.addView(mapMainView);
        this.setMaxZoomValue(maxZoomValue);
        this.mapMainView.registeMapViewListener(svgMapViewListener);
        this.loadMap(floorId + ".svg");
    }

    public void setCurrentFloor(InputStream inputStream, final SVGMapViewListener svgMapViewListener) {
        this.setBackgroundColor(Color.WHITE);
        this.removeView(mapMainView);
        mapMainView = new MapMainView(context, attrs, defStyle);
        this.addView(mapMainView);
        this.mapMainView.registeMapViewListener(svgMapViewListener);
        this.loadMap(inputStream);
    }

    /**
     * @param inputStream
     * @param svgMapViewListener
     * @param maxZoomValue       最大缩放级别
     */
    public void setCurrentFloor(InputStream inputStream, final SVGMapViewListener svgMapViewListener, float maxZoomValue) {
        this.setBackgroundColor(Color.WHITE);
        this.removeView(mapMainView);
        mapMainView = new MapMainView(context, attrs, defStyle);
        this.addView(mapMainView);
        this.setMaxZoomValue(maxZoomValue);
        this.mapMainView.registeMapViewListener(svgMapViewListener);
        this.loadMap(inputStream);
    }

    /**
     * @param inputStream
     * @param svgMapViewListener
     * @param maxZoomValue       最大缩放级别
     */
    public void setCurrentFloor(InputStream inputStream, final SVGMapViewListener svgMapViewListener, float maxZoomValue, final SVGMapViewOtherClickListener svgMapViewOtherClickListener) {
        this.setBackgroundColor(Color.WHITE);
        this.removeView(mapMainView);
        mapMainView = new MapMainView(context, attrs, defStyle);
        this.addView(mapMainView);
        this.setMaxZoomValue(maxZoomValue);
        this.mapMainView.registeMapViewListener(svgMapViewListener);
        this.mapMainView.registerMapViewOtherClickListener(svgMapViewOtherClickListener);
        this.loadMap(inputStream);
    }


    /**
     * @param assetManager
     * @param floorId
     * @param svgMapViewListener
     * @param maxZoomValue       最大缩放级别
     */
    public void setCurrentFloor(AssetManager assetManager, String floorId, final SVGMapViewListener svgMapViewListener, float maxZoomValue) {
        this.setBackgroundColor(Color.WHITE);
        this.removeView(mapMainView);
        mapMainView = new MapMainView(context, attrs, defStyle);
        this.addView(mapMainView);
        this.setMaxZoomValue(maxZoomValue);
        this.mapMainView.registeMapViewListener(svgMapViewListener);
        this.loadMap(assetManager, floorId + ".svg");
    }

    public void setCurrentFloor(AssetManager assetManager, String floorId, final SVGMapViewListener svgMapViewListener) {
        // 加载对应楼层的地图
        this.setBackgroundColor(Color.WHITE);
        this.removeView(mapMainView);
        mapMainView = new MapMainView(context, attrs, defStyle);
        this.addView(mapMainView);
        //        this.mapMainView.getOverLays().clear();
        //        this.mapMainView.refresh();
        this.mapMainView.registeMapViewListener(svgMapViewListener);
        this.loadMap(assetManager, floorId + ".svg");
        //        this.mapMainView.registeMapViewListener(new SVGMapViewListener() {
        //            @Override
        //            public void onMapLoadComplete(long floorId, String buildingName) {
        //                if (svgMapViewListener != null) {
        //                    svgMapViewListener.onMapLoadComplete(floorId, buildingName);
        //                }
        //
        //                if (mapMainView!=null) {
        //                    mapMainView.mapCenter(true, true);
        //                }
        //            }
        //
        //            @Override
        //            public void onMapLoadError() {
        //                if (svgMapViewListener != null) {
        //                    svgMapViewListener.onMapLoadError();
        //                }
        //            }
        //
        //            @Override
        //            public void onGetCurrentMap(Bitmap bitmap) {
        //                if (svgMapViewListener != null) {
        //                    svgMapViewListener.onGetCurrentMap(bitmap);
        //                }
        //            }
        //        });
    }


    public FloorsFeature getFloorFeature() {
        return mapMainView.getFloorFeature();
    }

    public List<POIData> poiSearch(int type, float x, float y) {
        List<POIData> poiDataList = new ArrayList<>();
        for (int i = 0; i < mapMainView.getFloorFeature().getFeatures().size(); i++) {
            Map<Long, Feature> featureMap = mapMainView.getFloorFeature().getFeatures().get(i);

            for (Map.Entry<Long, Feature> entry : featureMap.entrySet()) {
                if (entry.getValue().getSpaceType() == type /*|| type == -1*/) {
                    POIData poiData = new POIData();
                    poiData.setPoi_id(entry.getValue().getFeature_id());
                    poiData.setUrl("");
                    poiData.setName(entry.getValue().getName());
                    poiData.setCenter_x(entry.getValue().getCenter_x());
                    poiData.setCenter_y(entry.getValue().getCenter_y());
//                    poiData.setFloor_id(entry.getValue().getFeature_id());
                    poiData.setFloor_id(getFloorFeature().getFloor_id());
                    poiData.setLocation(mapMainView.getFloorFeature().getLocation());
                    poiData.setSpaceType(entry.getValue().getSpaceType());
                    poiData.setDistance(getDistance(x, y, entry.getValue().getCenter_x(), entry.getValue().getCenter_y()));
                    poiDataList.add(poiData);
                }
            }
        }
        return poiDataList;
    }

    /* 设置地图居中显示 */
    public void setMapCenter() {
        mapMainView.mapCenter(true, true);
    }

    private float getDistance(float x, float y, float centerX, float centerY) {
        return (float) Math.sqrt(Math.abs((centerY - y)) * Math.abs((centerY - y)) + Math.abs((centerX - x)) * Math.abs((centerX - x)));
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }
}
